package algo_lignes_sites.data.junction;

import algo_lignes_sites.data.force.ForceAccumulator;
import algo_lignes_sites.params.objects.contraintesgeom.ContrainteGeomNode;
import commons.data.Attributes;
import commons.data.EchelleGeneralization;
import commons.data.Model.TypeField;
import commons.data.Zones;
import commons.io.in.Point_in;
import commons.utils.Utils;
import java.awt.Color;
import java.util.ArrayList;
import java.util.Date;



public class NodeData {

	public Attributes attributes;
	public Zones zones;
	// Contient l'échelle maximum à laquelle doit être "grossi" le node durant le traitement
	public EchelleGeneralization echelleGeneralization;
	public ContrainteGeomNode contrainteGeom;
	public Color color;

	// algo >= v22 : si ce node est temporaire car fusion d'autres node durant le traitement
	public ArrayList<Point_in> vNodeInitFusionne;
	public boolean isNodeTemporaireFusionne() {return vNodeInitFusionne!=null;}
			
	// Utilisée pour le tri des node pour l'affichage
	protected Comparable valueToCompare_forDisplay;


	// V18 données pour Simplification Adaptative
//	public double complexite_initiale = 0; notion abandonnée, cf. CalculComplexite
	public double complexite_apresSimplif = 0;
	
	
	// Il s'agit d'une réduction  du coef d'influencement. La zone d'influencement reste la même !
	// 1 -> on ne change rien à l'attenuation de répulsion, 0 -> on annule complètement l'attenuation de répulsion
	public double factReductionInfluenceNode = 1;

	// Utilisé lors de la phase de simplification des nodes
	public boolean bSimplified; // savoir si un node a deja ete simplifié
	public double rayon_Simplification_m; // pour affichage debug (le rayon peut etre reduit si conflit (plusieurs nodes trop proches)
	public double k_correctif;
	
	
	// Utilisé pour le calcul des forces répulsives
	public int nbIntersectionRepulsive = 0;
	public String detailsIntersectionRepulsive = "";
	public double maxLargeurPathOfIntersectionRepulsive = 0.0;
	public int nbJunctionMultiExplulsable = 0;

	// Forces s'appliquant au node
	public ForceAccumulator accuForceRepuls_Seg_Node;
	public ForceAccumulator accuForceRepuls_Node_Node;
	
	
	// Donnnées uniques communes à tous les Nodes
	static public String champLibelleNode;
	static public String champTriNode;
	static public TypeField typeChampTriNode; // va servir pour faciliter le tri
	static public boolean bBiggestOnTop;
	static public void setChampLibelleNode(String champLibelleNode) {NodeData.champLibelleNode=champLibelleNode;}
	// a n'appeler qu'une fois, et avant toute transformation d'un A_Junction en NODE -> car la valeur pour la comparaison est precalculée une seule fois au changement de type en NODE
	static public void setChampTriNode(String champTriNode, TypeField typeChampTriNode) {NodeData.champTriNode=champTriNode; NodeData.typeChampTriNode = typeChampTriNode;}
	static public void setbBiggestOnTop(boolean bBiggestOnTop) {NodeData.bBiggestOnTop=bBiggestOnTop;}


	// vNodeInitFusionne : algo >= v22 : si ce node est temporaire car fusion d'autres node durant le traitement
	public NodeData(Attributes attributes, Zones zones, ContrainteGeomNode cgn, EchelleGeneralization eg, Color color, ArrayList<Point_in> vNodeInitFusionne) {
		this.attributes=attributes;
		this.zones=zones;
		this.contrainteGeom = cgn;
		this.echelleGeneralization = eg;
		this.color = color;
		this.vNodeInitFusionne = vNodeInitFusionne;
		
		this.bSimplified = false;
		
		computeValueToCompare_forDisplay();
	}

	
	// Prépare et stocke valeur servant a trier les Node (pour l'affichage) appelé par le constructeur du node
	//  -> dans le bon type (d'interface Comparable) pour accélérer les tri ultérieurs
	public void computeValueToCompare_forDisplay() {

		String val = attributes.getValue(NodeData.champTriNode);

		switch (typeChampTriNode) {
			case INT:
				if (val == null || val.length()==0 || !Utils.isInteger(val))
					valueToCompare_forDisplay = new Integer(0);
				else
					valueToCompare_forDisplay = new Integer(val);
				break;

			case DBL:
				if (val == null || val.length()==0 || !Utils.isFloat(val))
					valueToCompare_forDisplay = new Double(0);
				else
					valueToCompare_forDisplay = new Double(val);
				break;

			case DAT:
				if (val == null || val.length()==0 || !Utils.isDate(val))
					valueToCompare_forDisplay = new Date(0);
				else
					valueToCompare_forDisplay = Utils.parseDate(val);
				break;

			case TXT:
				valueToCompare_forDisplay = val;
				break;

			default:
				assert (false);
				valueToCompare_forDisplay = "";
		}
	}


}
